// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2011 Benoit Jacob <jacob.benoit.1@gmail.com>
// Copyright (C) 2011-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
// Copyright (C) 2011-2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_COREEVALUATORS_H
#define EIGEN_COREEVALUATORS_H

namespace Eigen {

namespace internal {

// This class returns the evaluator kind from the expression storage kind.
// Default assumes index based accessors
template<typename StorageKind>
struct storage_kind_to_evaluator_kind
{
	typedef IndexBased Kind;
};

// This class returns the evaluator shape from the expression storage kind.
// It can be Dense, Sparse, Triangular, Diagonal, SelfAdjoint, Band, etc.
template<typename StorageKind>
struct storage_kind_to_shape;

template<>
struct storage_kind_to_shape<Dense>
{
	typedef DenseShape Shape;
};
template<>
struct storage_kind_to_shape<SolverStorage>
{
	typedef SolverShape Shape;
};
template<>
struct storage_kind_to_shape<PermutationStorage>
{
	typedef PermutationShape Shape;
};
template<>
struct storage_kind_to_shape<TranspositionsStorage>
{
	typedef TranspositionsShape Shape;
};

// Evaluators have to be specialized with respect to various criteria such as:
//  - storage/structure/shape
//  - scalar type
//  - etc.
// Therefore, we need specialization of evaluator providing additional template arguments for each kind of evaluators.
// We currently distinguish the following kind of evaluators:
// - unary_evaluator    for expressions taking only one arguments (CwiseUnaryOp, CwiseUnaryView, Transpose,
// MatrixWrapper, ArrayWrapper, Reverse, Replicate)
// - binary_evaluator   for expression taking two arguments (CwiseBinaryOp)
// - ternary_evaluator   for expression taking three arguments (CwiseTernaryOp)
// - product_evaluator  for linear algebra products (Product); special case of binary_evaluator because it requires
// additional tags for dispatching.
// - mapbase_evaluator  for Map, Block, Ref
// - block_evaluator    for Block (special dispatching to a mapbase_evaluator or unary_evaluator)

template<typename T,
		 typename Arg1Kind = typename evaluator_traits<typename T::Arg1>::Kind,
		 typename Arg2Kind = typename evaluator_traits<typename T::Arg2>::Kind,
		 typename Arg3Kind = typename evaluator_traits<typename T::Arg3>::Kind,
		 typename Arg1Scalar = typename traits<typename T::Arg1>::Scalar,
		 typename Arg2Scalar = typename traits<typename T::Arg2>::Scalar,
		 typename Arg3Scalar = typename traits<typename T::Arg3>::Scalar>
struct ternary_evaluator;

template<typename T,
		 typename LhsKind = typename evaluator_traits<typename T::Lhs>::Kind,
		 typename RhsKind = typename evaluator_traits<typename T::Rhs>::Kind,
		 typename LhsScalar = typename traits<typename T::Lhs>::Scalar,
		 typename RhsScalar = typename traits<typename T::Rhs>::Scalar>
struct binary_evaluator;

template<typename T,
		 typename Kind = typename evaluator_traits<typename T::NestedExpression>::Kind,
		 typename Scalar = typename T::Scalar>
struct unary_evaluator;

// evaluator_traits<T> contains traits for evaluator<T>

template<typename T>
struct evaluator_traits_base
{
	// by default, get evaluator kind and shape from storage
	typedef typename storage_kind_to_evaluator_kind<typename traits<T>::StorageKind>::Kind Kind;
	typedef typename storage_kind_to_shape<typename traits<T>::StorageKind>::Shape Shape;
};

// Default evaluator traits
template<typename T>
struct evaluator_traits : public evaluator_traits_base<T>
{};

template<typename T, typename Shape = typename evaluator_traits<T>::Shape>
struct evaluator_assume_aliasing
{
	static const bool value = false;
};

// By default, we assume a unary expression:
template<typename T>
struct evaluator : public unary_evaluator<T>
{
	typedef unary_evaluator<T> Base;
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const T& xpr)
		: Base(xpr)
	{
	}
};

// TODO: Think about const-correctness
template<typename T>
struct evaluator<const T> : evaluator<T>
{
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const T& xpr)
		: evaluator<T>(xpr)
	{
	}
};

// ---------- base class for all evaluators ----------

template<typename ExpressionType>
struct evaluator_base
{
	// TODO that's not very nice to have to propagate all these traits. They are currently only needed to handle
	// outer,inner indices.
	typedef traits<ExpressionType> ExpressionTraits;

	enum
	{
		Alignment = 0
	};
	// noncopyable:
	// Don't make this class inherit noncopyable as this kills EBO (Empty Base Optimization)
	// and make complex evaluator much larger than then should do.
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator_base() {}
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ~evaluator_base() {}

  private:
	EIGEN_DEVICE_FUNC evaluator_base(const evaluator_base&);
	EIGEN_DEVICE_FUNC const evaluator_base& operator=(const evaluator_base&);
};

// -------------------- Matrix and Array --------------------
//
// evaluator<PlainObjectBase> is a common base class for the
// Matrix and Array evaluators.
// Here we directly specialize evaluator. This is not really a unary expression, and it is, by definition, dense,
// so no need for more sophisticated dispatching.

// this helper permits to completely eliminate m_outerStride if it is known at compiletime.
template<typename Scalar, int OuterStride>
class plainobjectbase_evaluator_data
{
  public:
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride)
		: data(ptr)
	{
#ifndef EIGEN_INTERNAL_DEBUGGING
		EIGEN_UNUSED_VARIABLE(outerStride);
#endif
		eigen_internal_assert(outerStride == OuterStride);
	}
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index outerStride() const EIGEN_NOEXCEPT
	{
		return OuterStride;
	}
	const Scalar* data;
};

template<typename Scalar>
class plainobjectbase_evaluator_data<Scalar, Dynamic>
{
  public:
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE plainobjectbase_evaluator_data(const Scalar* ptr, Index outerStride)
		: data(ptr)
		, m_outerStride(outerStride)
	{
	}
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Index outerStride() const { return m_outerStride; }
	const Scalar* data;

  protected:
	Index m_outerStride;
};

template<typename Derived>
struct evaluator<PlainObjectBase<Derived>> : evaluator_base<Derived>
{
	typedef PlainObjectBase<Derived> PlainObjectType;
	typedef typename PlainObjectType::Scalar Scalar;
	typedef typename PlainObjectType::CoeffReturnType CoeffReturnType;

	enum
	{
		IsRowMajor = PlainObjectType::IsRowMajor,
		IsVectorAtCompileTime = PlainObjectType::IsVectorAtCompileTime,
		RowsAtCompileTime = PlainObjectType::RowsAtCompileTime,
		ColsAtCompileTime = PlainObjectType::ColsAtCompileTime,

		CoeffReadCost = NumTraits<Scalar>::ReadCost,
		Flags = traits<Derived>::EvaluatorFlags,
		Alignment = traits<Derived>::Alignment
	};
	enum
	{
		// We do not need to know the outer stride for vectors
		OuterStrideAtCompileTime = IsVectorAtCompileTime ? 0
								   : int(IsRowMajor)	 ? ColsAtCompileTime
														 : RowsAtCompileTime
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator()
		: m_d(0, OuterStrideAtCompileTime)
	{
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const PlainObjectType& m)
		: m_d(m.data(), IsVectorAtCompileTime ? 0 : m.outerStride())
	{
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		if (IsRowMajor)
			return m_d.data[row * m_d.outerStride() + col];
		else
			return m_d.data[row + col * m_d.outerStride()];
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_d.data[index]; }

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
	{
		if (IsRowMajor)
			return const_cast<Scalar*>(m_d.data)[row * m_d.outerStride() + col];
		else
			return const_cast<Scalar*>(m_d.data)[row + col * m_d.outerStride()];
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return const_cast<Scalar*>(m_d.data)[index]; }

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		if (IsRowMajor)
			return ploadt<PacketType, LoadMode>(m_d.data + row * m_d.outerStride() + col);
		else
			return ploadt<PacketType, LoadMode>(m_d.data + row + col * m_d.outerStride());
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		return ploadt<PacketType, LoadMode>(m_d.data + index);
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x)
	{
		if (IsRowMajor)
			return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar*>(m_d.data) + row * m_d.outerStride() + col,
														  x);
		else
			return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar*>(m_d.data) + row + col * m_d.outerStride(),
														  x);
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x)
	{
		return pstoret<Scalar, PacketType, StoreMode>(const_cast<Scalar*>(m_d.data) + index, x);
	}

  protected:
	plainobjectbase_evaluator_data<Scalar, OuterStrideAtCompileTime> m_d;
};

template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
struct evaluator<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>
	: evaluator<PlainObjectBase<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>>
{
	typedef Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator() {}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& m)
		: evaluator<PlainObjectBase<XprType>>(m)
	{
	}
};

template<typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
struct evaluator<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>
	: evaluator<PlainObjectBase<Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>>
{
	typedef Array<Scalar, Rows, Cols, Options, MaxRows, MaxCols> XprType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE evaluator() {}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& m)
		: evaluator<PlainObjectBase<XprType>>(m)
	{
	}
};

// -------------------- Transpose --------------------

template<typename ArgType>
struct unary_evaluator<Transpose<ArgType>, IndexBased> : evaluator_base<Transpose<ArgType>>
{
	typedef Transpose<ArgType> XprType;

	enum
	{
		CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
		Flags = evaluator<ArgType>::Flags ^ RowMajorBit,
		Alignment = evaluator<ArgType>::Alignment
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& t)
		: m_argImpl(t.nestedExpression())
	{
	}

	typedef typename XprType::Scalar Scalar;
	typedef typename XprType::CoeffReturnType CoeffReturnType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		return m_argImpl.coeff(col, row);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_argImpl.coeff(index); }

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
	{
		return m_argImpl.coeffRef(col, row);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename XprType::Scalar& coeffRef(Index index)
	{
		return m_argImpl.coeffRef(index);
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		return m_argImpl.template packet<LoadMode, PacketType>(col, row);
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		return m_argImpl.template packet<LoadMode, PacketType>(index);
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x)
	{
		m_argImpl.template writePacket<StoreMode, PacketType>(col, row, x);
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x)
	{
		m_argImpl.template writePacket<StoreMode, PacketType>(index, x);
	}

  protected:
	evaluator<ArgType> m_argImpl;
};

// -------------------- CwiseNullaryOp --------------------
// Like Matrix and Array, this is not really a unary expression, so we directly specialize evaluator.
// Likewise, there is not need to more sophisticated dispatching here.

template<typename Scalar,
		 typename NullaryOp,
		 bool has_nullary = has_nullary_operator<NullaryOp>::value,
		 bool has_unary = has_unary_operator<NullaryOp>::value,
		 bool has_binary = has_binary_operator<NullaryOp>::value>
struct nullary_wrapper
{
	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const
	{
		return op(i, j);
	}
	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const
	{
		return op(i);
	}

	template<typename T, typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const
	{
		return op.template packetOp<T>(i, j);
	}
	template<typename T, typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const
	{
		return op.template packetOp<T>(i);
	}
};

template<typename Scalar, typename NullaryOp>
struct nullary_wrapper<Scalar, NullaryOp, true, false, false>
{
	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType = 0, IndexType = 0) const
	{
		return op();
	}
	template<typename T, typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType = 0, IndexType = 0) const
	{
		return op.template packetOp<T>();
	}
};

template<typename Scalar, typename NullaryOp>
struct nullary_wrapper<Scalar, NullaryOp, false, false, true>
{
	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j = 0) const
	{
		return op(i, j);
	}
	template<typename T, typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j = 0) const
	{
		return op.template packetOp<T>(i, j);
	}
};

// We need the following specialization for vector-only functors assigned to a runtime vector,
// for instance, using linspace and assigning a RowVectorXd to a MatrixXd or even a row of a MatrixXd.
// In this case, i==0 and j is used for the actual iteration.
template<typename Scalar, typename NullaryOp>
struct nullary_wrapper<Scalar, NullaryOp, false, true, false>
{
	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const
	{
		eigen_assert(i == 0 || j == 0);
		return op(i + j);
	}
	template<typename T, typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const
	{
		eigen_assert(i == 0 || j == 0);
		return op.template packetOp<T>(i + j);
	}

	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const
	{
		return op(i);
	}
	template<typename T, typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const
	{
		return op.template packetOp<T>(i);
	}
};

template<typename Scalar, typename NullaryOp>
struct nullary_wrapper<Scalar, NullaryOp, false, false, false>
{};

#if 0 && EIGEN_COMP_MSVC > 0
// Disable this ugly workaround. This is now handled in traits<Ref>::match,
// but this piece of code might still become handly if some other weird compilation
// erros pop up again.

// MSVC exhibits a weird compilation error when
// compiling:
//    Eigen::MatrixXf A = MatrixXf::Random(3,3);
//    Ref<const MatrixXf> R = 2.f*A;
// and that has_*ary_operator<scalar_constant_op<float>> have not been instantiated yet.
// The "problem" is that evaluator<2.f*A> is instantiated by traits<Ref>::match<2.f*A>
// and at that time has_*ary_operator<T> returns true regardless of T.
// Then nullary_wrapper is badly instantiated as nullary_wrapper<.,.,true,true,true>.
// The trick is thus to defer the proper instantiation of nullary_wrapper when coeff(),
// and packet() are really instantiated as implemented below:

// This is a simple wrapper around Index to enforce the re-instantiation of
// has_*ary_operator when needed.
template<typename T> struct nullary_wrapper_workaround_msvc {
  nullary_wrapper_workaround_msvc(const T&);
  operator T()const;
};

template<typename Scalar,typename NullaryOp>
struct nullary_wrapper<Scalar,NullaryOp,true,true,true>
{
  template <typename IndexType>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i, IndexType j) const {
    return nullary_wrapper<Scalar,NullaryOp,
    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i,j);
  }
  template <typename IndexType>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar operator()(const NullaryOp& op, IndexType i) const {
    return nullary_wrapper<Scalar,NullaryOp,
    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().operator()(op,i);
  }

  template <typename T, typename IndexType>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i, IndexType j) const {
    return nullary_wrapper<Scalar,NullaryOp,
    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i,j);
  }
  template <typename T, typename IndexType>
  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T packetOp(const NullaryOp& op, IndexType i) const {
    return nullary_wrapper<Scalar,NullaryOp,
    has_nullary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
    has_unary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value,
    has_binary_operator<NullaryOp,nullary_wrapper_workaround_msvc<IndexType> >::value>().template packetOp<T>(op,i);
  }
};
#endif // MSVC workaround

template<typename NullaryOp, typename PlainObjectType>
struct evaluator<CwiseNullaryOp<NullaryOp, PlainObjectType>>
	: evaluator_base<CwiseNullaryOp<NullaryOp, PlainObjectType>>
{
	typedef CwiseNullaryOp<NullaryOp, PlainObjectType> XprType;
	typedef typename internal::remove_all<PlainObjectType>::type PlainObjectTypeCleaned;

	enum
	{
		CoeffReadCost = internal::functor_traits<NullaryOp>::Cost,

		Flags = (evaluator<PlainObjectTypeCleaned>::Flags &
				 (HereditaryBits | (functor_has_linear_access<NullaryOp>::ret ? LinearAccessBit : 0) |
				  (functor_traits<NullaryOp>::PacketAccess ? PacketAccessBit : 0))) |
				(functor_traits<NullaryOp>::IsRepeatable ? 0 : EvalBeforeNestingBit),
		Alignment = AlignedMax
	};

	EIGEN_DEVICE_FUNC explicit evaluator(const XprType& n)
		: m_functor(n.functor())
		, m_wrapper()
	{
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	typedef typename XprType::CoeffReturnType CoeffReturnType;

	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(IndexType row, IndexType col) const
	{
		return m_wrapper(m_functor, row, col);
	}

	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(IndexType index) const
	{
		return m_wrapper(m_functor, index);
	}

	template<int LoadMode, typename PacketType, typename IndexType>
	EIGEN_STRONG_INLINE PacketType packet(IndexType row, IndexType col) const
	{
		return m_wrapper.template packetOp<PacketType>(m_functor, row, col);
	}

	template<int LoadMode, typename PacketType, typename IndexType>
	EIGEN_STRONG_INLINE PacketType packet(IndexType index) const
	{
		return m_wrapper.template packetOp<PacketType>(m_functor, index);
	}

  protected:
	const NullaryOp m_functor;
	const internal::nullary_wrapper<CoeffReturnType, NullaryOp> m_wrapper;
};

// -------------------- CwiseUnaryOp --------------------

template<typename UnaryOp, typename ArgType>
struct unary_evaluator<CwiseUnaryOp<UnaryOp, ArgType>, IndexBased> : evaluator_base<CwiseUnaryOp<UnaryOp, ArgType>>
{
	typedef CwiseUnaryOp<UnaryOp, ArgType> XprType;

	enum
	{
		CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),

		Flags = evaluator<ArgType>::Flags &
				(HereditaryBits | LinearAccessBit | (functor_traits<UnaryOp>::PacketAccess ? PacketAccessBit : 0)),
		Alignment = evaluator<ArgType>::Alignment
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& op)
		: m_d(op)
	{
		EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	typedef typename XprType::CoeffReturnType CoeffReturnType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		return m_d.func()(m_d.argImpl.coeff(row, col));
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		return m_d.func()(m_d.argImpl.coeff(index));
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(row, col));
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		return m_d.func().packetOp(m_d.argImpl.template packet<LoadMode, PacketType>(index));
	}

  protected:
	// this helper permits to completely eliminate the functor if it is empty
	struct Data
	{
		EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Data(const XprType& xpr)
			: op(xpr.functor())
			, argImpl(xpr.nestedExpression())
		{
		}
		EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const UnaryOp& func() const { return op; }
		UnaryOp op;
		evaluator<ArgType> argImpl;
	};

	Data m_d;
};

// -------------------- CwiseTernaryOp --------------------

// this is a ternary expression
template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
struct evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>>
	: public ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>>
{
	typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;
	typedef ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>> Base;

	EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
		: Base(xpr)
	{
	}
};

template<typename TernaryOp, typename Arg1, typename Arg2, typename Arg3>
struct ternary_evaluator<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>, IndexBased, IndexBased>
	: evaluator_base<CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3>>
{
	typedef CwiseTernaryOp<TernaryOp, Arg1, Arg2, Arg3> XprType;

	enum
	{
		CoeffReadCost = int(evaluator<Arg1>::CoeffReadCost) + int(evaluator<Arg2>::CoeffReadCost) +
						int(evaluator<Arg3>::CoeffReadCost) + int(functor_traits<TernaryOp>::Cost),

		Arg1Flags = evaluator<Arg1>::Flags,
		Arg2Flags = evaluator<Arg2>::Flags,
		Arg3Flags = evaluator<Arg3>::Flags,
		SameType = is_same<typename Arg1::Scalar, typename Arg2::Scalar>::value &&
				   is_same<typename Arg1::Scalar, typename Arg3::Scalar>::value,
		StorageOrdersAgree = (int(Arg1Flags) & RowMajorBit) == (int(Arg2Flags) & RowMajorBit) &&
							 (int(Arg1Flags) & RowMajorBit) == (int(Arg3Flags) & RowMajorBit),
		Flags0 =
			(int(Arg1Flags) | int(Arg2Flags) | int(Arg3Flags)) &
			(HereditaryBits |
			 (int(Arg1Flags) & int(Arg2Flags) & int(Arg3Flags) &
			  ((StorageOrdersAgree ? LinearAccessBit : 0) |
			   (functor_traits<TernaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)))),
		Flags = (Flags0 & ~RowMajorBit) | (Arg1Flags & RowMajorBit),
		Alignment = EIGEN_PLAIN_ENUM_MIN(EIGEN_PLAIN_ENUM_MIN(evaluator<Arg1>::Alignment, evaluator<Arg2>::Alignment),
										 evaluator<Arg3>::Alignment)
	};

	EIGEN_DEVICE_FUNC explicit ternary_evaluator(const XprType& xpr)
		: m_d(xpr)
	{
		EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<TernaryOp>::Cost);
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	typedef typename XprType::CoeffReturnType CoeffReturnType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		return m_d.func()(m_d.arg1Impl.coeff(row, col), m_d.arg2Impl.coeff(row, col), m_d.arg3Impl.coeff(row, col));
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		return m_d.func()(m_d.arg1Impl.coeff(index), m_d.arg2Impl.coeff(index), m_d.arg3Impl.coeff(index));
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode, PacketType>(row, col),
								   m_d.arg2Impl.template packet<LoadMode, PacketType>(row, col),
								   m_d.arg3Impl.template packet<LoadMode, PacketType>(row, col));
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		return m_d.func().packetOp(m_d.arg1Impl.template packet<LoadMode, PacketType>(index),
								   m_d.arg2Impl.template packet<LoadMode, PacketType>(index),
								   m_d.arg3Impl.template packet<LoadMode, PacketType>(index));
	}

  protected:
	// this helper permits to completely eliminate the functor if it is empty
	struct Data
	{
		EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Data(const XprType& xpr)
			: op(xpr.functor())
			, arg1Impl(xpr.arg1())
			, arg2Impl(xpr.arg2())
			, arg3Impl(xpr.arg3())
		{
		}
		EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const TernaryOp& func() const { return op; }
		TernaryOp op;
		evaluator<Arg1> arg1Impl;
		evaluator<Arg2> arg2Impl;
		evaluator<Arg3> arg3Impl;
	};

	Data m_d;
};

// -------------------- CwiseBinaryOp --------------------

// this is a binary expression
template<typename BinaryOp, typename Lhs, typename Rhs>
struct evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> : public binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>
{
	typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
	typedef binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> Base;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& xpr)
		: Base(xpr)
	{
	}
};

template<typename BinaryOp, typename Lhs, typename Rhs>
struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>, IndexBased, IndexBased>
	: evaluator_base<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>
{
	typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;

	enum
	{
		CoeffReadCost = int(evaluator<Lhs>::CoeffReadCost) + int(evaluator<Rhs>::CoeffReadCost) +
						int(functor_traits<BinaryOp>::Cost),

		LhsFlags = evaluator<Lhs>::Flags,
		RhsFlags = evaluator<Rhs>::Flags,
		SameType = is_same<typename Lhs::Scalar, typename Rhs::Scalar>::value,
		StorageOrdersAgree = (int(LhsFlags) & RowMajorBit) == (int(RhsFlags) & RowMajorBit),
		Flags0 = (int(LhsFlags) | int(RhsFlags)) &
				 (HereditaryBits |
				  (int(LhsFlags) & int(RhsFlags) &
				   ((StorageOrdersAgree ? LinearAccessBit : 0) |
					(functor_traits<BinaryOp>::PacketAccess && StorageOrdersAgree && SameType ? PacketAccessBit : 0)))),
		Flags = (Flags0 & ~RowMajorBit) | (LhsFlags & RowMajorBit),
		Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<Lhs>::Alignment, evaluator<Rhs>::Alignment)
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit binary_evaluator(const XprType& xpr)
		: m_d(xpr)
	{
		EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<BinaryOp>::Cost);
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	typedef typename XprType::CoeffReturnType CoeffReturnType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		return m_d.func()(m_d.lhsImpl.coeff(row, col), m_d.rhsImpl.coeff(row, col));
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		return m_d.func()(m_d.lhsImpl.coeff(index), m_d.rhsImpl.coeff(index));
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode, PacketType>(row, col),
								   m_d.rhsImpl.template packet<LoadMode, PacketType>(row, col));
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		return m_d.func().packetOp(m_d.lhsImpl.template packet<LoadMode, PacketType>(index),
								   m_d.rhsImpl.template packet<LoadMode, PacketType>(index));
	}

  protected:
	// this helper permits to completely eliminate the functor if it is empty
	struct Data
	{
		EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Data(const XprType& xpr)
			: op(xpr.functor())
			, lhsImpl(xpr.lhs())
			, rhsImpl(xpr.rhs())
		{
		}
		EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const BinaryOp& func() const { return op; }
		BinaryOp op;
		evaluator<Lhs> lhsImpl;
		evaluator<Rhs> rhsImpl;
	};

	Data m_d;
};

// -------------------- CwiseUnaryView --------------------

template<typename UnaryOp, typename ArgType>
struct unary_evaluator<CwiseUnaryView<UnaryOp, ArgType>, IndexBased> : evaluator_base<CwiseUnaryView<UnaryOp, ArgType>>
{
	typedef CwiseUnaryView<UnaryOp, ArgType> XprType;

	enum
	{
		CoeffReadCost = int(evaluator<ArgType>::CoeffReadCost) + int(functor_traits<UnaryOp>::Cost),

		Flags = (evaluator<ArgType>::Flags & (HereditaryBits | LinearAccessBit | DirectAccessBit)),

		Alignment = 0 // FIXME it is not very clear why alignment is necessarily lost...
	};

	EIGEN_DEVICE_FUNC explicit unary_evaluator(const XprType& op)
		: m_d(op)
	{
		EIGEN_INTERNAL_CHECK_COST_VALUE(functor_traits<UnaryOp>::Cost);
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	typedef typename XprType::Scalar Scalar;
	typedef typename XprType::CoeffReturnType CoeffReturnType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		return m_d.func()(m_d.argImpl.coeff(row, col));
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		return m_d.func()(m_d.argImpl.coeff(index));
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
	{
		return m_d.func()(m_d.argImpl.coeffRef(row, col));
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
	{
		return m_d.func()(m_d.argImpl.coeffRef(index));
	}

  protected:
	// this helper permits to completely eliminate the functor if it is empty
	struct Data
	{
		EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Data(const XprType& xpr)
			: op(xpr.functor())
			, argImpl(xpr.nestedExpression())
		{
		}
		EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const UnaryOp& func() const { return op; }
		UnaryOp op;
		evaluator<ArgType> argImpl;
	};

	Data m_d;
};

// -------------------- Map --------------------

// FIXME perhaps the PlainObjectType could be provided by Derived::PlainObject ?
// but that might complicate template specialization
template<typename Derived, typename PlainObjectType>
struct mapbase_evaluator;

template<typename Derived, typename PlainObjectType>
struct mapbase_evaluator : evaluator_base<Derived>
{
	typedef Derived XprType;
	typedef typename XprType::PointerType PointerType;
	typedef typename XprType::Scalar Scalar;
	typedef typename XprType::CoeffReturnType CoeffReturnType;

	enum
	{
		IsRowMajor = XprType::RowsAtCompileTime,
		ColsAtCompileTime = XprType::ColsAtCompileTime,
		CoeffReadCost = NumTraits<Scalar>::ReadCost
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit mapbase_evaluator(const XprType& map)
		: m_data(const_cast<PointerType>(map.data()))
		, m_innerStride(map.innerStride())
		, m_outerStride(map.outerStride())
	{
		EIGEN_STATIC_ASSERT(EIGEN_IMPLIES(evaluator<Derived>::Flags & PacketAccessBit,
										  internal::inner_stride_at_compile_time<Derived>::ret == 1),
							PACKET_ACCESS_REQUIRES_TO_HAVE_INNER_STRIDE_FIXED_TO_1);
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		return m_data[col * colStride() + row * rowStride()];
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		return m_data[index * m_innerStride.value()];
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
	{
		return m_data[col * colStride() + row * rowStride()];
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
	{
		return m_data[index * m_innerStride.value()];
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		PointerType ptr = m_data + row * rowStride() + col * colStride();
		return internal::ploadt<PacketType, LoadMode>(ptr);
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		return internal::ploadt<PacketType, LoadMode>(m_data + index * m_innerStride.value());
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x)
	{
		PointerType ptr = m_data + row * rowStride() + col * colStride();
		return internal::pstoret<Scalar, PacketType, StoreMode>(ptr, x);
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x)
	{
		internal::pstoret<Scalar, PacketType, StoreMode>(m_data + index * m_innerStride.value(), x);
	}

  protected:
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index rowStride() const EIGEN_NOEXCEPT
	{
		return XprType::IsRowMajor ? m_outerStride.value() : m_innerStride.value();
	}
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index colStride() const EIGEN_NOEXCEPT
	{
		return XprType::IsRowMajor ? m_innerStride.value() : m_outerStride.value();
	}

	PointerType m_data;
	const internal::variable_if_dynamic<Index, XprType::InnerStrideAtCompileTime> m_innerStride;
	const internal::variable_if_dynamic<Index, XprType::OuterStrideAtCompileTime> m_outerStride;
};

template<typename PlainObjectType, int MapOptions, typename StrideType>
struct evaluator<Map<PlainObjectType, MapOptions, StrideType>>
	: public mapbase_evaluator<Map<PlainObjectType, MapOptions, StrideType>, PlainObjectType>
{
	typedef Map<PlainObjectType, MapOptions, StrideType> XprType;
	typedef typename XprType::Scalar Scalar;
	// TODO: should check for smaller packet types once we can handle multi-sized packet types
	typedef typename packet_traits<Scalar>::type PacketScalar;

	enum
	{
		InnerStrideAtCompileTime = StrideType::InnerStrideAtCompileTime == 0
									   ? int(PlainObjectType::InnerStrideAtCompileTime)
									   : int(StrideType::InnerStrideAtCompileTime),
		OuterStrideAtCompileTime = StrideType::OuterStrideAtCompileTime == 0
									   ? int(PlainObjectType::OuterStrideAtCompileTime)
									   : int(StrideType::OuterStrideAtCompileTime),
		HasNoInnerStride = InnerStrideAtCompileTime == 1,
		HasNoOuterStride = StrideType::OuterStrideAtCompileTime == 0,
		HasNoStride = HasNoInnerStride && HasNoOuterStride,
		IsDynamicSize = PlainObjectType::SizeAtCompileTime == Dynamic,

		PacketAccessMask = bool(HasNoInnerStride) ? ~int(0) : ~int(PacketAccessBit),
		LinearAccessMask =
			bool(HasNoStride) || bool(PlainObjectType::IsVectorAtCompileTime) ? ~int(0) : ~int(LinearAccessBit),
		Flags = int(evaluator<PlainObjectType>::Flags) & (LinearAccessMask & PacketAccessMask),

		Alignment = int(MapOptions) & int(AlignedMask)
	};

	EIGEN_DEVICE_FUNC explicit evaluator(const XprType& map)
		: mapbase_evaluator<XprType, PlainObjectType>(map)
	{
	}
};

// -------------------- Ref --------------------

template<typename PlainObjectType, int RefOptions, typename StrideType>
struct evaluator<Ref<PlainObjectType, RefOptions, StrideType>>
	: public mapbase_evaluator<Ref<PlainObjectType, RefOptions, StrideType>, PlainObjectType>
{
	typedef Ref<PlainObjectType, RefOptions, StrideType> XprType;

	enum
	{
		Flags = evaluator<Map<PlainObjectType, RefOptions, StrideType>>::Flags,
		Alignment = evaluator<Map<PlainObjectType, RefOptions, StrideType>>::Alignment
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& ref)
		: mapbase_evaluator<XprType, PlainObjectType>(ref)
	{
	}
};

// -------------------- Block --------------------

template<typename ArgType,
		 int BlockRows,
		 int BlockCols,
		 bool InnerPanel,
		 bool HasDirectAccess = internal::has_direct_access<ArgType>::ret>
struct block_evaluator;

template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
struct evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>>
	: block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel>
{
	typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
	typedef typename XprType::Scalar Scalar;
	// TODO: should check for smaller packet types once we can handle multi-sized packet types
	typedef typename packet_traits<Scalar>::type PacketScalar;

	enum
	{
		CoeffReadCost = evaluator<ArgType>::CoeffReadCost,

		RowsAtCompileTime = traits<XprType>::RowsAtCompileTime,
		ColsAtCompileTime = traits<XprType>::ColsAtCompileTime,
		MaxRowsAtCompileTime = traits<XprType>::MaxRowsAtCompileTime,
		MaxColsAtCompileTime = traits<XprType>::MaxColsAtCompileTime,

		ArgTypeIsRowMajor = (int(evaluator<ArgType>::Flags) & RowMajorBit) != 0,
		IsRowMajor = (MaxRowsAtCompileTime == 1 && MaxColsAtCompileTime != 1)	? 1
					 : (MaxColsAtCompileTime == 1 && MaxRowsAtCompileTime != 1) ? 0
																				: ArgTypeIsRowMajor,
		HasSameStorageOrderAsArgType = (IsRowMajor == ArgTypeIsRowMajor),
		InnerSize = IsRowMajor ? int(ColsAtCompileTime) : int(RowsAtCompileTime),
		InnerStrideAtCompileTime = HasSameStorageOrderAsArgType ? int(inner_stride_at_compile_time<ArgType>::ret)
																: int(outer_stride_at_compile_time<ArgType>::ret),
		OuterStrideAtCompileTime = HasSameStorageOrderAsArgType ? int(outer_stride_at_compile_time<ArgType>::ret)
																: int(inner_stride_at_compile_time<ArgType>::ret),
		MaskPacketAccessBit = (InnerStrideAtCompileTime == 1 || HasSameStorageOrderAsArgType) ? PacketAccessBit : 0,

		FlagsLinearAccessBit = (RowsAtCompileTime == 1 || ColsAtCompileTime == 1 ||
								(InnerPanel && (evaluator<ArgType>::Flags & LinearAccessBit)))
								   ? LinearAccessBit
								   : 0,
		FlagsRowMajorBit = XprType::Flags & RowMajorBit,
		Flags0 = evaluator<ArgType>::Flags & ((HereditaryBits & ~RowMajorBit) | DirectAccessBit | MaskPacketAccessBit),
		Flags = Flags0 | FlagsLinearAccessBit | FlagsRowMajorBit,

		PacketAlignment = unpacket_traits<PacketScalar>::alignment,
		Alignment0 = (InnerPanel && (OuterStrideAtCompileTime != Dynamic) && (OuterStrideAtCompileTime != 0) &&
					  (((OuterStrideAtCompileTime * int(sizeof(Scalar))) % int(PacketAlignment)) == 0))
						 ? int(PacketAlignment)
						 : 0,
		Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ArgType>::Alignment, Alignment0)
	};
	typedef block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel> block_evaluator_type;
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& block)
		: block_evaluator_type(block)
	{
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}
};

// no direct-access => dispatch to a unary evaluator
template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /*HasDirectAccess*/ false>
	: unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>>
{
	typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit block_evaluator(const XprType& block)
		: unary_evaluator<XprType>(block)
	{
	}
};

template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
struct unary_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>, IndexBased>
	: evaluator_base<Block<ArgType, BlockRows, BlockCols, InnerPanel>>
{
	typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& block)
		: m_argImpl(block.nestedExpression())
		, m_startRow(block.startRow())
		, m_startCol(block.startCol())
		, m_linear_offset(ForwardLinearAccess
							  ? (ArgType::IsRowMajor
									 ? block.startRow() * block.nestedExpression().cols() + block.startCol()
									 : block.startCol() * block.nestedExpression().rows() + block.startRow())
							  : 0)
	{
	}

	typedef typename XprType::Scalar Scalar;
	typedef typename XprType::CoeffReturnType CoeffReturnType;

	enum
	{
		RowsAtCompileTime = XprType::RowsAtCompileTime,
		ForwardLinearAccess = (InnerPanel || int(XprType::IsRowMajor) == int(ArgType::IsRowMajor)) &&
							  bool(evaluator<ArgType>::Flags & LinearAccessBit)
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		return m_argImpl.coeff(m_startRow.value() + row, m_startCol.value() + col);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		return linear_coeff_impl(index, bool_constant<ForwardLinearAccess>());
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
	{
		return m_argImpl.coeffRef(m_startRow.value() + row, m_startCol.value() + col);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
	{
		return linear_coeffRef_impl(index, bool_constant<ForwardLinearAccess>());
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		return m_argImpl.template packet<LoadMode, PacketType>(m_startRow.value() + row, m_startCol.value() + col);
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		if (ForwardLinearAccess)
			return m_argImpl.template packet<LoadMode, PacketType>(m_linear_offset.value() + index);
		else
			return packet<LoadMode, PacketType>(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x)
	{
		return m_argImpl.template writePacket<StoreMode, PacketType>(
			m_startRow.value() + row, m_startCol.value() + col, x);
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x)
	{
		if (ForwardLinearAccess)
			return m_argImpl.template writePacket<StoreMode, PacketType>(m_linear_offset.value() + index, x);
		else
			return writePacket<StoreMode, PacketType>(
				RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0, x);
	}

  protected:
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType
	linear_coeff_impl(Index index, internal::true_type /* ForwardLinearAccess */) const
	{
		return m_argImpl.coeff(m_linear_offset.value() + index);
	}
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType
	linear_coeff_impl(Index index, internal::false_type /* not ForwardLinearAccess */) const
	{
		return coeff(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& linear_coeffRef_impl(Index index,
																	   internal::true_type /* ForwardLinearAccess */)
	{
		return m_argImpl.coeffRef(m_linear_offset.value() + index);
	}
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& linear_coeffRef_impl(
		Index index,
		internal::false_type /* not ForwardLinearAccess */)
	{
		return coeffRef(RowsAtCompileTime == 1 ? 0 : index, RowsAtCompileTime == 1 ? index : 0);
	}

	evaluator<ArgType> m_argImpl;
	const variable_if_dynamic<Index, (ArgType::RowsAtCompileTime == 1 && BlockRows == 1) ? 0 : Dynamic> m_startRow;
	const variable_if_dynamic<Index, (ArgType::ColsAtCompileTime == 1 && BlockCols == 1) ? 0 : Dynamic> m_startCol;
	const variable_if_dynamic<Index, ForwardLinearAccess ? Dynamic : 0> m_linear_offset;
};

// TODO: This evaluator does not actually use the child evaluator;
// all action is via the data() as returned by the Block expression.

template<typename ArgType, int BlockRows, int BlockCols, bool InnerPanel>
struct block_evaluator<ArgType, BlockRows, BlockCols, InnerPanel, /* HasDirectAccess */ true>
	: mapbase_evaluator<Block<ArgType, BlockRows, BlockCols, InnerPanel>,
						typename Block<ArgType, BlockRows, BlockCols, InnerPanel>::PlainObject>
{
	typedef Block<ArgType, BlockRows, BlockCols, InnerPanel> XprType;
	typedef typename XprType::Scalar Scalar;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit block_evaluator(const XprType& block)
		: mapbase_evaluator<XprType, typename XprType::PlainObject>(block)
	{
		// TODO: for the 3.3 release, this should be turned to an internal assertion, but let's keep it as is for the
		// beta lifetime
		eigen_assert(
			((internal::UIntPtr(block.data()) % EIGEN_PLAIN_ENUM_MAX(1, evaluator<XprType>::Alignment)) == 0) &&
			"data is not aligned");
	}
};

// -------------------- Select --------------------
// NOTE shall we introduce a ternary_evaluator?

// TODO enable vectorization for Select
template<typename ConditionMatrixType, typename ThenMatrixType, typename ElseMatrixType>
struct evaluator<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType>>
	: evaluator_base<Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType>>
{
	typedef Select<ConditionMatrixType, ThenMatrixType, ElseMatrixType> XprType;
	enum
	{
		CoeffReadCost =
			evaluator<ConditionMatrixType>::CoeffReadCost +
			EIGEN_PLAIN_ENUM_MAX(evaluator<ThenMatrixType>::CoeffReadCost, evaluator<ElseMatrixType>::CoeffReadCost),

		Flags = (unsigned int)evaluator<ThenMatrixType>::Flags & evaluator<ElseMatrixType>::Flags & HereditaryBits,

		Alignment = EIGEN_PLAIN_ENUM_MIN(evaluator<ThenMatrixType>::Alignment, evaluator<ElseMatrixType>::Alignment)
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& select)
		: m_conditionImpl(select.conditionMatrix())
		, m_thenImpl(select.thenMatrix())
		, m_elseImpl(select.elseMatrix())
	{
		EIGEN_INTERNAL_CHECK_COST_VALUE(CoeffReadCost);
	}

	typedef typename XprType::CoeffReturnType CoeffReturnType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		if (m_conditionImpl.coeff(row, col))
			return m_thenImpl.coeff(row, col);
		else
			return m_elseImpl.coeff(row, col);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		if (m_conditionImpl.coeff(index))
			return m_thenImpl.coeff(index);
		else
			return m_elseImpl.coeff(index);
	}

  protected:
	evaluator<ConditionMatrixType> m_conditionImpl;
	evaluator<ThenMatrixType> m_thenImpl;
	evaluator<ElseMatrixType> m_elseImpl;
};

// -------------------- Replicate --------------------

template<typename ArgType, int RowFactor, int ColFactor>
struct unary_evaluator<Replicate<ArgType, RowFactor, ColFactor>>
	: evaluator_base<Replicate<ArgType, RowFactor, ColFactor>>
{
	typedef Replicate<ArgType, RowFactor, ColFactor> XprType;
	typedef typename XprType::CoeffReturnType CoeffReturnType;
	enum
	{
		Factor = (RowFactor == Dynamic || ColFactor == Dynamic) ? Dynamic : RowFactor * ColFactor
	};
	typedef typename internal::nested_eval<ArgType, Factor>::type ArgTypeNested;
	typedef typename internal::remove_all<ArgTypeNested>::type ArgTypeNestedCleaned;

	enum
	{
		CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
		LinearAccessMask = XprType::IsVectorAtCompileTime ? LinearAccessBit : 0,
		Flags = (evaluator<ArgTypeNestedCleaned>::Flags & (HereditaryBits | LinearAccessMask) & ~RowMajorBit) |
				(traits<XprType>::Flags & RowMajorBit),

		Alignment = evaluator<ArgTypeNestedCleaned>::Alignment
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& replicate)
		: m_arg(replicate.nestedExpression())
		, m_argImpl(m_arg)
		, m_rows(replicate.nestedExpression().rows())
		, m_cols(replicate.nestedExpression().cols())
	{
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		// try to avoid using modulo; this is a pure optimization strategy
		const Index actual_row = internal::traits<XprType>::RowsAtCompileTime == 1 ? 0
								 : RowFactor == 1								   ? row
																				   : row % m_rows.value();
		const Index actual_col = internal::traits<XprType>::ColsAtCompileTime == 1 ? 0
								 : ColFactor == 1								   ? col
																				   : col % m_cols.value();

		return m_argImpl.coeff(actual_row, actual_col);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		// try to avoid using modulo; this is a pure optimization strategy
		const Index actual_index = internal::traits<XprType>::RowsAtCompileTime == 1
									   ? (ColFactor == 1 ? index : index % m_cols.value())
									   : (RowFactor == 1 ? index : index % m_rows.value());

		return m_argImpl.coeff(actual_index);
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		const Index actual_row = internal::traits<XprType>::RowsAtCompileTime == 1 ? 0
								 : RowFactor == 1								   ? row
																				   : row % m_rows.value();
		const Index actual_col = internal::traits<XprType>::ColsAtCompileTime == 1 ? 0
								 : ColFactor == 1								   ? col
																				   : col % m_cols.value();

		return m_argImpl.template packet<LoadMode, PacketType>(actual_row, actual_col);
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		const Index actual_index = internal::traits<XprType>::RowsAtCompileTime == 1
									   ? (ColFactor == 1 ? index : index % m_cols.value())
									   : (RowFactor == 1 ? index : index % m_rows.value());

		return m_argImpl.template packet<LoadMode, PacketType>(actual_index);
	}

  protected:
	const ArgTypeNested m_arg;
	evaluator<ArgTypeNestedCleaned> m_argImpl;
	const variable_if_dynamic<Index, ArgType::RowsAtCompileTime> m_rows;
	const variable_if_dynamic<Index, ArgType::ColsAtCompileTime> m_cols;
};

// -------------------- MatrixWrapper and ArrayWrapper --------------------
//
// evaluator_wrapper_base<T> is a common base class for the
// MatrixWrapper and ArrayWrapper evaluators.

template<typename XprType>
struct evaluator_wrapper_base : evaluator_base<XprType>
{
	typedef typename remove_all<typename XprType::NestedExpressionType>::type ArgType;
	enum
	{
		CoeffReadCost = evaluator<ArgType>::CoeffReadCost,
		Flags = evaluator<ArgType>::Flags,
		Alignment = evaluator<ArgType>::Alignment
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator_wrapper_base(const ArgType& arg)
		: m_argImpl(arg)
	{
	}

	typedef typename ArgType::Scalar Scalar;
	typedef typename ArgType::CoeffReturnType CoeffReturnType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		return m_argImpl.coeff(row, col);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const { return m_argImpl.coeff(index); }

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
	{
		return m_argImpl.coeffRef(row, col);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index) { return m_argImpl.coeffRef(index); }

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		return m_argImpl.template packet<LoadMode, PacketType>(row, col);
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		return m_argImpl.template packet<LoadMode, PacketType>(index);
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x)
	{
		m_argImpl.template writePacket<StoreMode>(row, col, x);
	}

	template<int StoreMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x)
	{
		m_argImpl.template writePacket<StoreMode>(index, x);
	}

  protected:
	evaluator<ArgType> m_argImpl;
};

template<typename TArgType>
struct unary_evaluator<MatrixWrapper<TArgType>> : evaluator_wrapper_base<MatrixWrapper<TArgType>>
{
	typedef MatrixWrapper<TArgType> XprType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& wrapper)
		: evaluator_wrapper_base<MatrixWrapper<TArgType>>(wrapper.nestedExpression())
	{
	}
};

template<typename TArgType>
struct unary_evaluator<ArrayWrapper<TArgType>> : evaluator_wrapper_base<ArrayWrapper<TArgType>>
{
	typedef ArrayWrapper<TArgType> XprType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& wrapper)
		: evaluator_wrapper_base<ArrayWrapper<TArgType>>(wrapper.nestedExpression())
	{
	}
};

// -------------------- Reverse --------------------

// defined in Reverse.h:
template<typename PacketType, bool ReversePacket>
struct reverse_packet_cond;

template<typename ArgType, int Direction>
struct unary_evaluator<Reverse<ArgType, Direction>> : evaluator_base<Reverse<ArgType, Direction>>
{
	typedef Reverse<ArgType, Direction> XprType;
	typedef typename XprType::Scalar Scalar;
	typedef typename XprType::CoeffReturnType CoeffReturnType;

	enum
	{
		IsRowMajor = XprType::IsRowMajor,
		IsColMajor = !IsRowMajor,
		ReverseRow = (Direction == Vertical) || (Direction == BothDirections),
		ReverseCol = (Direction == Horizontal) || (Direction == BothDirections),
		ReversePacket = (Direction == BothDirections) || ((Direction == Vertical) && IsColMajor) ||
						((Direction == Horizontal) && IsRowMajor),

		CoeffReadCost = evaluator<ArgType>::CoeffReadCost,

		// let's enable LinearAccess only with vectorization because of the product overhead
		// FIXME enable DirectAccess with negative strides?
		Flags0 = evaluator<ArgType>::Flags,
		LinearAccess =
			((Direction == BothDirections) && (int(Flags0) & PacketAccessBit)) ||
					((ReverseRow && XprType::ColsAtCompileTime == 1) || (ReverseCol && XprType::RowsAtCompileTime == 1))
				? LinearAccessBit
				: 0,

		Flags = int(Flags0) & (HereditaryBits | PacketAccessBit | LinearAccess),

		Alignment = 0 // FIXME in some rare cases, Alignment could be preserved, like a Vector4f.
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit unary_evaluator(const XprType& reverse)
		: m_argImpl(reverse.nestedExpression())
		, m_rows(ReverseRow ? reverse.nestedExpression().rows() : 1)
		, m_cols(ReverseCol ? reverse.nestedExpression().cols() : 1)
	{
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index col) const
	{
		return m_argImpl.coeff(ReverseRow ? m_rows.value() - row - 1 : row,
							   ReverseCol ? m_cols.value() - col - 1 : col);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		return m_argImpl.coeff(m_rows.value() * m_cols.value() - index - 1);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index col)
	{
		return m_argImpl.coeffRef(ReverseRow ? m_rows.value() - row - 1 : row,
								  ReverseCol ? m_cols.value() - col - 1 : col);
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
	{
		return m_argImpl.coeffRef(m_rows.value() * m_cols.value() - index - 1);
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index row, Index col) const
	{
		enum
		{
			PacketSize = unpacket_traits<PacketType>::size,
			OffsetRow = ReverseRow && IsColMajor ? PacketSize : 1,
			OffsetCol = ReverseCol && IsRowMajor ? PacketSize : 1
		};
		typedef internal::reverse_packet_cond<PacketType, ReversePacket> reverse_packet;
		return reverse_packet::run(m_argImpl.template packet<LoadMode, PacketType>(
			ReverseRow ? m_rows.value() - row - OffsetRow : row, ReverseCol ? m_cols.value() - col - OffsetCol : col));
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE PacketType packet(Index index) const
	{
		enum
		{
			PacketSize = unpacket_traits<PacketType>::size
		};
		return preverse(
			m_argImpl.template packet<LoadMode, PacketType>(m_rows.value() * m_cols.value() - index - PacketSize));
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index row, Index col, const PacketType& x)
	{
		// FIXME we could factorize some code with packet(i,j)
		enum
		{
			PacketSize = unpacket_traits<PacketType>::size,
			OffsetRow = ReverseRow && IsColMajor ? PacketSize : 1,
			OffsetCol = ReverseCol && IsRowMajor ? PacketSize : 1
		};
		typedef internal::reverse_packet_cond<PacketType, ReversePacket> reverse_packet;
		m_argImpl.template writePacket<LoadMode>(ReverseRow ? m_rows.value() - row - OffsetRow : row,
												 ReverseCol ? m_cols.value() - col - OffsetCol : col,
												 reverse_packet::run(x));
	}

	template<int LoadMode, typename PacketType>
	EIGEN_STRONG_INLINE void writePacket(Index index, const PacketType& x)
	{
		enum
		{
			PacketSize = unpacket_traits<PacketType>::size
		};
		m_argImpl.template writePacket<LoadMode>(m_rows.value() * m_cols.value() - index - PacketSize, preverse(x));
	}

  protected:
	evaluator<ArgType> m_argImpl;

	// If we do not reverse rows, then we do not need to know the number of rows; same for columns
	// Nonetheless, in this case it is important to set to 1 such that the coeff(index) method works fine for vectors.
	const variable_if_dynamic<Index, ReverseRow ? ArgType::RowsAtCompileTime : 1> m_rows;
	const variable_if_dynamic<Index, ReverseCol ? ArgType::ColsAtCompileTime : 1> m_cols;
};

// -------------------- Diagonal --------------------

template<typename ArgType, int DiagIndex>
struct evaluator<Diagonal<ArgType, DiagIndex>> : evaluator_base<Diagonal<ArgType, DiagIndex>>
{
	typedef Diagonal<ArgType, DiagIndex> XprType;

	enum
	{
		CoeffReadCost = evaluator<ArgType>::CoeffReadCost,

		Flags = (unsigned int)(evaluator<ArgType>::Flags & (HereditaryBits | DirectAccessBit) & ~RowMajorBit) |
				LinearAccessBit,

		Alignment = 0
	};

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE explicit evaluator(const XprType& diagonal)
		: m_argImpl(diagonal.nestedExpression())
		, m_index(diagonal.index())
	{
	}

	typedef typename XprType::Scalar Scalar;
	typedef typename XprType::CoeffReturnType CoeffReturnType;

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index row, Index) const
	{
		return m_argImpl.coeff(row + rowOffset(), row + colOffset());
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE CoeffReturnType coeff(Index index) const
	{
		return m_argImpl.coeff(index + rowOffset(), index + colOffset());
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index row, Index)
	{
		return m_argImpl.coeffRef(row + rowOffset(), row + colOffset());
	}

	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Scalar& coeffRef(Index index)
	{
		return m_argImpl.coeffRef(index + rowOffset(), index + colOffset());
	}

  protected:
	evaluator<ArgType> m_argImpl;
	const internal::variable_if_dynamicindex<Index, XprType::DiagIndex> m_index;

  private:
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index rowOffset() const
	{
		return m_index.value() > 0 ? 0 : -m_index.value();
	}
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR Index colOffset() const
	{
		return m_index.value() > 0 ? m_index.value() : 0;
	}
};

//----------------------------------------------------------------------
// deprecated code
//----------------------------------------------------------------------

// -------------------- EvalToTemp --------------------

// expression class for evaluating nested expression to a temporary

template<typename ArgType>
class EvalToTemp;

template<typename ArgType>
struct traits<EvalToTemp<ArgType>> : public traits<ArgType>
{};

template<typename ArgType>
class EvalToTemp : public dense_xpr_base<EvalToTemp<ArgType>>::type
{
  public:
	typedef typename dense_xpr_base<EvalToTemp>::type Base;
	EIGEN_GENERIC_PUBLIC_INTERFACE(EvalToTemp)

	explicit EvalToTemp(const ArgType& arg)
		: m_arg(arg)
	{
	}

	const ArgType& arg() const { return m_arg; }

	EIGEN_CONSTEXPR Index rows() const EIGEN_NOEXCEPT { return m_arg.rows(); }

	EIGEN_CONSTEXPR Index cols() const EIGEN_NOEXCEPT { return m_arg.cols(); }

  private:
	const ArgType& m_arg;
};

template<typename ArgType>
struct evaluator<EvalToTemp<ArgType>> : public evaluator<typename ArgType::PlainObject>
{
	typedef EvalToTemp<ArgType> XprType;
	typedef typename ArgType::PlainObject PlainObject;
	typedef evaluator<PlainObject> Base;

	EIGEN_DEVICE_FUNC explicit evaluator(const XprType& xpr)
		: m_result(xpr.arg())
	{
		::new (static_cast<Base*>(this)) Base(m_result);
	}

	// This constructor is used when nesting an EvalTo evaluator in another evaluator
	EIGEN_DEVICE_FUNC evaluator(const ArgType& arg)
		: m_result(arg)
	{
		::new (static_cast<Base*>(this)) Base(m_result);
	}

  protected:
	PlainObject m_result;
};

} // namespace internal

} // end namespace Eigen

#endif // EIGEN_COREEVALUATORS_H
